/****************************************************************************
 * libwiigui
 *
 * Tantric 2009
 *
 * gui_imagedata.cpp
 *
 * LoadJpeg copyright by r-win for WiiXplorer
 * check WiiXplorer source for license conditions
 *
 * GUI class definitions
 ***************************************************************************/

#include "gui.h"

#ifdef __cplusplus
extern "C"
{
#endif

#include <jpeglib.h>

#ifdef __cplusplus
}
#endif

#define new_width 640
#define new_height 480

/**
 * Constructor for the GuiImageData class.
 */

extern int idiotFlag;
extern char idiotChar[50];
GuiImageData::GuiImageData(const u8 * img)
{
	data = NULL;
	width = 0;
	height = 0;

	if(img)
	{
		PNGUPROP imgProp;
		IMGCTX ctx = PNGU_SelectImageFromBuffer(img);

		if(!ctx)
			return;

		int res = PNGU_GetImageProperties(ctx, &imgProp);
		//if (((4%imgProp.imgWidth)!=0)||((4%imgProp.imgHeight)!=0))idiotFlag=1;

		if(res == PNGU_OK)
		{
			int len = imgProp.imgWidth * imgProp.imgHeight * 4;
			if(len%32) len += (32-len%32);
			data = (u8 *)memalign (32, len);

			if(data)
			{
				res = PNGU_DecodeTo4x4RGBA8 (ctx, imgProp.imgWidth, imgProp.imgHeight, data, 255);

				if(res == PNGU_OK)
				{
					width = imgProp.imgWidth;
					height = imgProp.imgHeight;
					DCFlushRange(data, len);
				}
				else
				{
					free(data);
					data = NULL;
					idiotFlag=1;
					snprintf(idiotChar, sizeof(idiotChar), "%s", img);

				}
			}
		}
		PNGU_ReleaseImageContext (ctx);
	}
}

GuiImageData::GuiImageData(const u8 * img, int imgSize)
{
	data = NULL;
	width = 0;
	height = 0;

    if(img)
	{
        if (img[0] == 0xFF && img[1] == 0xD8) { // IMAGE_JPEG
            LoadJpeg(img, imgSize);
        }
	}
}
/**
 * Constructor for the GuiImageData class.
 */
GuiImageData::GuiImageData(const char * imgPath, const u8 * buffer)
{
	data = NULL;
	width = 0;
	height = 0;

	if(imgPath)
	{
		PNGUPROP imgProp;
		IMGCTX ctx = PNGU_SelectImageFromDevice(imgPath);
		//if (((4%imgProp.imgWidth)!=0)||((4%imgProp.imgHeight)!=0))idiotFlag=1;

		if(ctx)
		{
			int res = PNGU_GetImageProperties(ctx, &imgProp);

			if(res == PNGU_OK)
			{
				int len = imgProp.imgWidth * imgProp.imgHeight * 4;
				if(len%32) len += (32-len%32);
				data = (u8 *)memalign (32, len);

				if(data)
				{
					res = PNGU_DecodeTo4x4RGBA8 (ctx, imgProp.imgWidth, imgProp.imgHeight, data, 255);

					if(res == PNGU_OK)
					{
						width = imgProp.imgWidth;
						height = imgProp.imgHeight;
						DCFlushRange(data, len);
					}
					else
					{
						free(data);
						data = NULL;
						idiotFlag=1;
						snprintf(idiotChar, sizeof(idiotChar), "%s", imgPath);
					}
				}
			}
			PNGU_ReleaseImageContext (ctx);
		}
	}

	if (!data) //use buffer data instead
	{
		width = 0;
		height = 0;
		if(buffer)
		{
			PNGUPROP imgProp;
			IMGCTX ctx = PNGU_SelectImageFromBuffer(buffer);

			if(!ctx)
				return;

			int res = PNGU_GetImageProperties(ctx, &imgProp);

			if(res == PNGU_OK)
			{
				int len = imgProp.imgWidth * imgProp.imgHeight * 4;
				if(len%32) len += (32-len%32);
				data = (u8 *)memalign (32, len);

				if(data)
				{
					res = PNGU_DecodeTo4x4RGBA8 (ctx, imgProp.imgWidth, imgProp.imgHeight, data, 255);

					if(res == PNGU_OK)
					{
						width = imgProp.imgWidth;
						height = imgProp.imgHeight;
						DCFlushRange(data, len);
					}
					else
					{
						free(data);
						data = NULL;
					}
				}
			}
			PNGU_ReleaseImageContext (ctx);
		}
	}
}

/**
 * Constructor for the GuiImageData class.
 */
GuiImageData::GuiImageData(const char *path, const char *file, const u8 *buffer, bool force_widescreen/*=false*/, const u8 *wbuffer/*=NULL*/)
{
	data = NULL;
	width = 0;
	height = 0;
	char path_4_3[100];
	char path_16_9[100];
	char *imgPath;

	snprintf(path_4_3, sizeof(path_4_3), "%s%s", path, file);
	if(force_widescreen)
	{
		snprintf(path_16_9, sizeof(path_16_9), "%sw%s", path, file);
		imgPath = path_16_9;
		if(wbuffer)
			buffer = wbuffer;
	}
	else
		imgPath = path_4_3;

	for(;;)
	{
		if(imgPath)
		{
			PNGUPROP imgProp;
			IMGCTX ctx = PNGU_SelectImageFromDevice(imgPath);
			//if (((4%imgProp.imgWidth)!=0)||((4%imgProp.imgHeight)!=0))idiotFlag=1;

			if(ctx)
			{
				int res = PNGU_GetImageProperties(ctx, &imgProp);

				if(res == PNGU_OK)
				{
					int len = imgProp.imgWidth * imgProp.imgHeight * 4;
					if(len%32) len += (32-len%32);
					data = (u8 *)memalign (32, len);

					if(data)
					{
						res = PNGU_DecodeTo4x4RGBA8 (ctx, imgProp.imgWidth, imgProp.imgHeight, data, 255);

						if(res == PNGU_OK)
						{
							width = imgProp.imgWidth;
							height = imgProp.imgHeight;
							DCFlushRange(data, len);
						}
						else
						{
							free(data);
							data = NULL;
							idiotFlag=1;
							snprintf(idiotChar, sizeof(idiotChar), "%s", imgPath);
						}
					}
				}
				PNGU_ReleaseImageContext (ctx);
			}
		}
		if(data || imgPath == path_4_3)
			break;
		imgPath = path_4_3;
	}

	if (!data) //use buffer data instead
	{
		width = 0;
		height = 0;
		if(buffer)
		{
			PNGUPROP imgProp;
			IMGCTX ctx = PNGU_SelectImageFromBuffer(buffer);

			if(!ctx)
				return;

			int res = PNGU_GetImageProperties(ctx, &imgProp);

			if(res == PNGU_OK)
			{
				int len = imgProp.imgWidth * imgProp.imgHeight * 4;
				if(len%32) len += (32-len%32);
				data = (u8 *)memalign (32, len);

				if(data)
				{
					res = PNGU_DecodeTo4x4RGBA8 (ctx, imgProp.imgWidth, imgProp.imgHeight, data, 255);

					if(res == PNGU_OK)
					{
						width = imgProp.imgWidth;
						height = imgProp.imgHeight;
						DCFlushRange(data, len);
					}
					else
					{
						free(data);
						data = NULL;
					}
				}
			}
			PNGU_ReleaseImageContext (ctx);
		}
	}
}

/**
 * Destructor for the GuiImageData class.
 */
GuiImageData::~GuiImageData()
{
	if(data)
	{
		free(data);
		data = NULL;
	}
}

u8 * GuiImageData::GetImage()
{
	return data;
}

int GuiImageData::GetWidth()
{
	return width;
}

int GuiImageData::GetHeight()
{
	return height;
}
void GuiImageData::SetGrayscale(void)
{
    GXColor color;
    u32 offset, gray;

    for(int x = 0; x < width; x++) {
        for(int y = 0; y < height; y++) {
            offset = (((y >> 2)<<4)*width) + ((x >> 2)<<6) + (((y%4 << 2) + x%4 ) << 1);
            color.r = *(data+offset+1);
            color.g = *(data+offset+32);
            color.b = *(data+offset+33);

            gray = (77*color.r + 150*color.g + 28*color.b)/255;

            *(data+offset+1) = gray;
            *(data+offset+32) = gray;
            *(data+offset+33) = gray;
        }
    }
}

// This function finds it's origin in GRRLIB, which can be found here: http://code.google.com/p/grrlib/
void GuiImageData::LoadJpeg(const u8 *img, int imgSize)
{
	struct jpeg_decompress_struct cinfo;
	struct jpeg_error_mgr jerr;

	int n = imgSize;

	while (n > 1) {
		if (img[n - 1] == 0xff && img[n] == 0xd9) {
			break;
		}
		n--;
	}

	jpeg_create_decompress(&cinfo);
    cinfo.err = jpeg_std_error(&jerr);
    cinfo.progress = NULL;
    jpeg_memory_src(&cinfo, img, n);
    jpeg_read_header(&cinfo, TRUE);
	jpeg_calc_output_dimensions(&cinfo);

	if (cinfo.output_width > new_width || cinfo.output_height > new_height)
	{
		float factor = (cinfo.output_width > cinfo.output_height) ? (1.0 * cinfo.output_width) / new_width : (1.0 * cinfo.output_height) / new_height;
		cinfo.scale_num = 1;
		cinfo.scale_denom = factor;
		cinfo.do_fancy_upsampling = true;
		cinfo.do_block_smoothing = false;
		cinfo.dct_method = JDCT_IFAST;
	}

    jpeg_start_decompress(&cinfo);

	int rowsize = cinfo.output_width * cinfo.num_components;
	unsigned char *tempBuffer = (unsigned char *) malloc(rowsize * cinfo.output_height);

    JSAMPROW row_pointer[1];

	row_pointer[0] = (unsigned char*) malloc(rowsize);
    size_t location = 0;
    while (cinfo.output_scanline < cinfo.output_height) {
        jpeg_read_scanlines(&cinfo, row_pointer, 1);
		memcpy(tempBuffer + location, row_pointer[0], rowsize);
		location += rowsize;
    }

	int len = ((cinfo.output_width+3)>>2)*((cinfo.output_height+3)>>2)*32*2;

    data = (u8 *) memalign(32, len);

	RawTo4x4RGBA(tempBuffer, data, cinfo.output_width, cinfo.output_height);
	DCFlushRange(data, len);

	width = cinfo.output_width;
	height = cinfo.output_height;

    jpeg_finish_decompress(&cinfo);
    jpeg_destroy_decompress(&cinfo);
    free(row_pointer[0]);
	free(tempBuffer);
}

/**
 * Convert a raw bmp (RGB, no alpha) to 4x4RGBA.
 * @author DragonMinded
 * @param src
 * @param dst
 * @param width
 * @param height
*/
void GuiImageData::RawTo4x4RGBA(const unsigned char *src, void *dst, const unsigned int width, const unsigned int height)
{
    unsigned int block;
    unsigned int i;
    unsigned int c;
    unsigned int ar;
    unsigned int gb;
    unsigned char *p = (unsigned char*)dst;

    for (block = 0; block < height; block += 4) {
        for (i = 0; i < width; i += 4) {
            /* Alpha and Red */
            for (c = 0; c < 4; ++c) {
                for (ar = 0; ar < 4; ++ar) {
                    /* Alpha pixels */
                    *p++ = 255;
                    /* Red pixels */
                    *p++ = src[((i + ar) + ((block + c) * width)) * 3];
                }
            }

            /* Green and Blue */
            for (c = 0; c < 4; ++c) {
                for (gb = 0; gb < 4; ++gb) {
                    /* Green pixels */
                    *p++ = src[(((i + gb) + ((block + c) * width)) * 3) + 1];
                    /* Blue pixels */
                    *p++ = src[(((i + gb) + ((block + c) * width)) * 3) + 2];
                }
            }
        } /* i */
    } /* block */
}
